package Class_Object.多态;

class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(this.name+"正在吃东西");
    }
    public Animal test(){
        return null;
    }
}
class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark() {
        System.out.println(this.name + "狗叫");
    }
    @Override  //这个只是个注解 ctrl+o
    public void eat() {
        //在继承关系上,满足方法返回值,方法名字,方法的参数列表一致,那么就是方法的重写
        System.out.println(this.name+"正在吃狗粮");

    }
    @Override
    public Dog test(){
        return null;//这个返回值父类是父类类型,子类为子类类型
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃猫粮");
    }

    @Override
    public Cat test() {
        return null;
    }
    public void miao() {
        System.out.println(this.name+"正在喵喵叫");
    }
}

public class Test {
    //向上转型
    //子类对象给父类
    public static void fuc(Animal animal) {
//TODO 传参进行向上转型
    }
    public static Dog fuc2(){
        Dog dog = new Dog("12",2);
        return dog;//TODO 返回值进行向上转型
    }

    public static void main2(String[] args) {
        //TODO 向下转型(很不安全)
        Animal animal = new Dog("小黑",8);//TODO 直接引用
        animal.eat();
//        animal.bark();
        Dog dog = (Dog)animal;
        dog.bark();
//        如果animal引用的对象是 Cat对象 的实例
        if(animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.miao();
        }else {
            System.out.println("animal引用的对象不是 Cat对象 的实例");
        }
    }

    public static void eatFunc(Animal animal) {
        animal.eat();//TODO 多态: 当父类引用 引用的子类对象不一样的时候,调用这个重写的方法,表现出来的行为是不一样的

}
    public static void main(String[] args) {
        Dog dog = new Dog("小白",9);
        Cat cat = new Cat("大白",89);
        eatFunc(dog);
        eatFunc(cat);


    }
    public static void main1(String[] args) {
        Dog dog = new Dog("小白",9);
        dog.eat();
        dog.bark();
        Animal animal1 = dog;//animal1这个引用指向了dog所指向的对象
        System.out.println("===========");
        Animal animal = new Dog("小黑",8);//TODO 直接引用
        animal.eat();
        fuc(dog);//这个也是向上转型
        Animal animal2 = fuc2();//这个也是向上转型
        animal.eat();//这个就是动态绑定,调用的时子类的eat(eat时父子类的重写方法)
        animal.test();//此时也是动态绑定(协变)
        System.out.println(dog);
        Animal animal3 = new Cat("大白",89);
    }
}
